import { collectUrl, loadUserMindOptions, loadSystemMindOptions, fetchGenerateAIContent, loadInfoTagOptions, relateTag } from "./service";
import { GetUrl } from "./model/GetUrl";
import { GetUrlPanel } from "./model/GetUrlPanel";
import { ToLogin } from "./model/MessageReceive";
import { CollectionManager } from "./model/CollectionManager";

async function sendMessage(id: number, message: any): Promise<any> {
    return new Promise((resolve, reject) => {
        try {
            // 检查标签页是否存在
            chrome.tabs.get(id, (tab) => {
                if (chrome.runtime.lastError) {
                    console.error('标签页不存在:', chrome.runtime.lastError);
                    return reject({
                        message: '标签页不存在',
                        error: chrome.runtime.lastError
                    });
                }
                
                // 发送消息到内容脚本
                chrome.tabs.sendMessage(id, message, function(response) {
                    if (chrome.runtime.lastError) {
                        console.error('发送消息失败:', chrome.runtime.lastError);
                        reject({
                            message: '发送消息失败',
                            error: chrome.runtime.lastError
                        });
                    } else {
                        resolve(response || {});
                    }
                });
            });
        } catch (error) {
            console.error('发送消息时发生异常:', error);
            reject({
                message: '发送消息时发生异常',
                error
            });
        }
    });
}

// 监听内容脚本就绪通知
// Listen for content script ready notification
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
    console.log('Background received message:', message);
    
    // 处理获取用户思维模型请求
    if (message.type === 'GET_USER_MIND_MODELS') {
        console.log('处理获取用户思维模型请求 - Processing get user mind models request');
        
        // 立即从缓存中读取数据并发送回去，然后再更新缓存
        chrome.storage.local.get(['userMindModels', 'user'], async (result) => {
            try {
                console.log('检查缓存数据 - Checking cached data');
                
                // 如果有缓存数据，先发送缓存数据
                if (result.userMindModels && Array.isArray(result.userMindModels) && result.userMindModels.length > 0) {
                    console.log('找到缓存数据，先发送 - Found cached data, sending first:', {
                        dataLength: result.userMindModels.length
                    });
                    
                    // 先发送缓存数据
                    sendResponse({
                        success: true,
                        data: result.userMindModels,
                        fromCache: true,
                        timestamp: new Date().getTime()
                    });
                }
                
                // 检查用户信息
                const user = result.user;
                if (!user) {
                    console.error('用户未登录 - User not logged in');
                    if (!result.userMindModels) { // 只有在没有发送过缓存数据的情况下才发送错误
                        sendResponse({ success: false, message: 'User not logged in' });
                    }
                    return;
                }
                
                // 调用 API 获取最新数据
                console.log('调用 loadUserMindOptions API - Calling loadUserMindOptions API');
                const mindModelsResponse = await loadUserMindOptions({
                    userGuid: user.userGuid,
                    accessToken: user.accessToken
                });
                
                console.log('思维模型加载结果 - Mind models loading result:', mindModelsResponse);
                
                // 将思维模型保存到storage
                if (mindModelsResponse.isSuccess) {
                    await chrome.storage.local.set({ 'userMindModels': mindModelsResponse.data });
                    console.log('已保存用户思维模型到storage - Saved user mind models to storage');
                    console.log('数据长度 - Data length:', mindModelsResponse.data ? mindModelsResponse.data.length : 0);
                    
                    // 如果没有发送过缓存数据，才发送新数据
                    if (!result.userMindModels || !Array.isArray(result.userMindModels) || result.userMindModels.length === 0) {
                        console.log('发送新获取的数据 - Sending newly fetched data');
                        sendResponse({ 
                            success: true, 
                            data: mindModelsResponse.data,
                            timestamp: new Date().getTime()
                        });
                    }
                } else {
                    console.error('加载用户思维模型失败 - Failed to load user mind models:', mindModelsResponse.message);
                    
                    // 如果没有发送过缓存数据，才发送错误
                    if (!result.userMindModels) {
                        sendResponse({ 
                            success: false, 
                            message: mindModelsResponse.message || 'Failed to load user mind models' 
                        });
                    }
                }
            } catch (error) {
                console.error('处理用户思维模型请求出错 - Error processing user mind models request:', error);
                
                // 如果没有发送过缓存数据，才发送错误
                if (!result.userMindModels) {
                    sendResponse({ 
                        success: false, 
                        message: error.message || 'Error processing request' 
                    });
                }
            }
        });
        
        // 返回 true 表示将异步发送响应
        return true;
    }
    
    // 处理获取系统思维模型请求
    if (message.type === 'GET_SYSTEM_MIND_MODELS') {
        console.log('处理获取系统思维模型请求 - Processing get system mind models request');
        
        (async () => {
            try {
                // 获取用户信息
                const result = await chrome.storage.local.get('user');
                const user = result.user;
                
                if (!user) {
                    console.error('用户未登录 - User not logged in');
                    sendResponse({ success: false, message: 'User not logged in' });
                    return;
                }
                
                // 调用 API 获取最新数据
                console.log('调用 loadSystemMindOptions API - Calling loadSystemMindOptions API');
                const mindModelsResponse = await loadSystemMindOptions({
                    userGuid: user.userGuid, // 添加 userGuid 参数
                    accessToken: user.accessToken
                });
                
                console.log('系统思维模型加载结果 - System mind models loading result:', mindModelsResponse);
                
                // 将系统思维模型保存到storage并返回
                if (mindModelsResponse.isSuccess) {
                    await chrome.storage.local.set({ 'systemMindModels': mindModelsResponse.data });
                    console.log('已保存系统思维模型到storage - Saved system mind models to storage');
                    sendResponse({ 
                        success: true, 
                        data: mindModelsResponse.data,
                        timestamp: new Date().getTime()
                    });
                } else {
                    console.error('加载系统思维模型失败 - Failed to load system mind models:', mindModelsResponse.message);
                    sendResponse({ 
                        success: false, 
                        message: mindModelsResponse.message || 'Failed to load system mind models' 
                    });
                }
            } catch (error) {
                console.error('处理系统思维模型请求出错 - Error processing system mind models request:', error);
                sendResponse({ 
                    success: false, 
                    message: error.message || 'Error processing request' 
                });
            }
        })();
        
        // 返回 true 表示将异步发送响应
        return true;
    }
    
    // 处理生成 AI 内容请求
    if (message.type === 'GENERATE_AI_CONTENT') {
        console.log('处理生成 AI 内容请求 - Processing generate AI content request');
        console.log('请求参数 - Request parameters:', message.params);
        
        (async () => {
            try {
                // 获取用户信息
                const result = await chrome.storage.local.get('user');
                const user = result.user;
                
                if (!user) {
                    console.error('用户未登录 - User not logged in');
                    sendResponse({ success: false, message: 'User not logged in' });
                    return;
                }
                
                const { infoGuid, mindPromptGuids } = message.params;
                
                if (!infoGuid) {
                    console.error('缺少 infoGuid 参数 - Missing infoGuid parameter');
                    sendResponse({ success: false, message: 'Missing infoGuid parameter' });
                    return;
                }
                
                if (!mindPromptGuids || !Array.isArray(mindPromptGuids) || mindPromptGuids.length === 0) {
                    console.error('缺少 mindPromptGuids 参数 - Missing mindPromptGuids parameter');
                    sendResponse({ success: false, message: 'Missing mindPromptGuids parameter' });
                    return;
                }
                
                // 调用 API 生成 AI 内容
                console.log('调用 fetchGenerateAIContent API - Calling fetchGenerateAIContent API');
                const apiResult = await fetchGenerateAIContent({
                    userGuid: user.userGuid,
                    infoGuid: infoGuid,
                    mindPromptGuids: mindPromptGuids,
                    accessToken: user.accessToken
                });
                
                console.log('AI 内容生成结果 - AI content generation result:', apiResult);
                
                if (apiResult.isSuccess) {
                    console.log('AI 内容生成成功 - AI content generated successfully');
                    sendResponse({ 
                        success: true, 
                        data: apiResult.data,
                        timestamp: new Date().getTime()
                    });
                } else {
                    console.error('AI 内容生成失败 - Failed to generate AI content:', apiResult.message);
                    sendResponse({ 
                        success: false, 
                        message: apiResult.message || 'Failed to generate AI content' 
                    });
                }
            } catch (error) {
                console.error('处理 AI 内容生成请求出错 - Error processing AI content generation request:', error);
                sendResponse({ 
                    success: false, 
                    message: error.message || 'Error processing request' 
                });
            }
        })();
        
        // 返回 true 表示将异步发送响应
        return true;
    }
    
    // 处理获取分类数据请求
    if (message.type === 'GET_CATEGORIES') {
        console.log('处理获取分类数据请求 - Processing get categories request');
        
        // 立即从缓存中读取数据并发送回去，然后再更新缓存
        chrome.storage.local.get(['categories', 'user'], async (result) => {
            try {
                console.log('检查分类缓存数据 - Checking cached categories data');
                
                // 如果有缓存数据，先发送缓存数据
                if (result.categories && Array.isArray(result.categories) && result.categories.length > 0) {
                    console.log('找到分类缓存数据，先发送 - Found cached categories data, sending first:', {
                        dataLength: result.categories.length
                    });
                    
                    // 先发送缓存数据
                    sendResponse({
                        success: true,
                        data: result.categories,
                        fromCache: true,
                        timestamp: new Date().getTime()
                    });
                }
                
                // 检查用户信息
                const user = result.user;
                if (!user) {
                    console.error('用户未登录 - User not logged in');
                    if (!result.categories) { // 只有在没有发送过缓存数据的情况下才发送错误
                        sendResponse({ success: false, message: 'User not logged in' });
                    }
                    return;
                }
                
                // 调用 API 获取最新数据
                console.log('调用 loadInfoTagOptions API - Calling loadInfoTagOptions API');
                const categoriesResponse = await loadInfoTagOptions({
                    userGuid: user.userGuid,
                    accessToken: user.accessToken
                });
                
                console.log('分类数据加载结果 - Categories loading result:', categoriesResponse);
                
                // 将分类数据保存到storage
                if (categoriesResponse.isSuccess) {
                    // 将API返回的数据转换为组件需要的格式
                    const formattedCategories = categoriesResponse.data.map((categoryName: string) => ({
                        value: categoryName,
                        label: categoryName
                    }));
                    
                    await chrome.storage.local.set({ 'categories': formattedCategories });
                    console.log('已保存分类数据到storage - Saved categories to storage');
                    console.log('数据长度 - Data length:', formattedCategories ? formattedCategories.length : 0);
                    
                    // 如果没有发送过缓存数据，才发送新数据
                    if (!result.categories || !Array.isArray(result.categories) || result.categories.length === 0) {
                        console.log('发送新获取的分类数据 - Sending newly fetched categories data');
                        sendResponse({ 
                            success: true, 
                            data: formattedCategories,
                            timestamp: new Date().getTime()
                        });
                    }
                } else {
                    console.error('加载分类数据失败 - Failed to load categories:', categoriesResponse.message);
                    
                    // 如果没有发送过缓存数据，才发送错误
                    if (!result.categories) {
                        sendResponse({ 
                            success: false, 
                            message: categoriesResponse.message || 'Failed to load categories' 
                        });
                    }
                }
            } catch (error) {
                console.error('处理分类数据请求出错 - Error processing categories request:', error);
                
                // 如果没有发送过缓存数据，才发送错误
                if (!result.categories) {
                    sendResponse({ 
                        success: false, 
                        message: error.message || 'Error processing request' 
                    });
                }
            }
        });
        
        // 返回 true 表示将异步发送响应
        return true;
    }
    
    // 处理关联标签请求
    if (message.type === 'RELATE_TAG') {
        console.log('处理关联标签请求 - Processing relate tag request');
        console.log('请求参数 - Request parameters:', message.params);
        
        (async () => {
            try {
                // 获取用户信息
                const result = await chrome.storage.local.get('user');
                const user = result.user;
                
                if (!user) {
                    console.error('用户未登录 - User not logged in');
                    sendResponse({ success: false, message: 'User not logged in' });
                    return;
                }
                
                const { infoGuid, tagName } = message.params;
                
                if (!infoGuid) {
                    console.error('缺少 infoGuid 参数 - Missing infoGuid parameter');
                    sendResponse({ success: false, message: 'Missing infoGuid parameter' });
                    return;
                }
                
                if (!tagName) {
                    console.error('缺少 tagName 参数 - Missing tagName parameter');
                    sendResponse({ success: false, message: 'Missing tagName parameter' });
                    return;
                }
                
                // 调用 API 关联标签
                console.log('调用 relateTag API - Calling relateTag API');
                const relateTagResponse = await relateTag({
                    infoGuid,
                    tagName,
                    userGuid: user.userGuid,
                    accessToken: user.accessToken
                });
                
                console.log('关联标签结果 - Relate tag result:', relateTagResponse);
                
                if (relateTagResponse.isSuccess) {
                    console.log('关联标签成功 - Relate tag successful');
                    sendResponse({ 
                        success: true, 
                        message: '分类关联成功 - Category associated successfully',
                        data: relateTagResponse.data 
                    });
                } else {
                    console.error('关联标签失败 - Failed to relate tag:', relateTagResponse.message);
                    sendResponse({ 
                        success: false, 
                        message: relateTagResponse.message || 'Failed to relate tag' 
                    });
                }
            } catch (error) {
                console.error('处理关联标签请求出错 - Error processing relate tag request:', error);
                sendResponse({ 
                    success: false, 
                    message: error.message || 'Error processing request' 
                });
            }
        })();
        
        // 返回 true 表示将异步发送响应
        return true;
    }
    
    if (message.type === 'CONTENT_SCRIPT_READY') {
        console.log('收到内容脚本就绪通知 - Content script ready notification received', sender.tab?.id);
        sendResponse({ status: 'acknowledged' });
    }
});

const onCollectCurrentPage = async (): Promise<void> => {
    // 获取当前页签
    chrome.tabs.query({ active: true, currentWindow: true }, async (tabs) => {
        const [activeTab] = tabs
        console.log('当前活动标签页 - Current active tab:', activeTab);

        // 获取用户信息
        const { user } = await chrome.storage.local.get('user')

        if (!user) {
            console.log('用户未登录，跳转到登录页面 - User not logged in, redirecting to login');
            sendMessage(activeTab.id, ToLogin.createToLoginAction())
            return
        }

        //初始打开
        // sendMessage(activeTab.id, GetUrl.createGetUrlStartAction())
        sendMessage(activeTab.id, GetUrlPanel.createGetUrlStartAction())        

        // 获取当前页面的 url
        // const result = await sendMessage(activeTab.id, GetUrl.createGetUrlAction())       
        const result = await sendMessage(activeTab.id, GetUrlPanel.createGetUrlAction())        
        // [收藏页面] - 调用服务端接口
        // 第一次请求，使用空字符串作为content
        let response = await collectUrl({
            url: result.url,
            title: result.title,
            content: "",  // 首次请求发送空字符串
            userGuid: user.userGuid,
            num: 1,
            accessToken: user.accessToken
        })
        console.log("First attempt response:", response);
        
        // 如果最终请求成功，显示成功通知
        if (response.isSuccess) {
            // 保存infoGuid到chrome.storage，以便GetUrlPanel组件使用
            if (response.data && response.data) {
                await chrome.storage.local.set({ 'lastInfoGuid': response.data });
                console.log('保存infoGuid到storage - Saved infoGuid to storage:', response.data);
                
                // 直接在background.ts中加载思维模型
                try {
                    // 获取用户信息
                    const userResult = await chrome.storage.local.get('user');
                    const user = userResult.user;
                    
                    if (user) {
                        console.log('在background.ts中加载思维模型 - Loading mind models in background.ts');
                        
                        // 加载用户思维模型
                        const mindModelsResponse = await loadUserMindOptions({
                            userGuid: user.userGuid,
                            accessToken: user.accessToken
                        });
                        
                        console.log('思维模型加载结果 - Mind models loading result:', mindModelsResponse);
                        
                        // 将思维模型保存到storage
                        if (mindModelsResponse.isSuccess) {
                            await chrome.storage.local.set({ 'userMindModels': mindModelsResponse.data });
                            console.log('已保存思维模型到storage - Saved mind models to storage');
                        }
                    }
                } catch (error) {
                    console.error('加载思维模型失败 - Failed to load mind models:', error);
                }
            }
            
            // 发送成功消息，并传递infoGuid
            sendMessage(activeTab.id, GetUrlPanel.createGetUrlResolveAction(response.data))
        }

        // // 如果第一次请求失败，尝试使用实际内容再次请求
        // if (!response.isSuccess) {
        //     console.log("First attempt failed, retrying with content");
        //     response = await collectUrl({
        //         url: result.url,
        //         title: result.title,
        //         content: result.content,  // 第二次请求发送实际内容
        //         userGuid: user.userGuid,
        //         num: 2,
        //         accessToken: user.accessToken
        //     })
        //     console.log("Second attempt response:", response);
        // }
        
        // // 如果最终请求成功，显示成功通知
        // if (response.isSuccess) {
        //     sendMessage(activeTab.id, GetUrl.createGetUrlResolveAction())
        // }

        //
        // 在发送消息前，确保内容脚本已加载
        // try {
        //     console.log('尝试执行内容脚本检查...');
            
        //     // // 尝试向页面发送一个检查消息，确认内容脚本是否已加载
        //     // await new Promise<void>((resolve, reject) => {
        //     //     // 设置超时，防止无限等待
        //     //     const timeout = setTimeout(() => {
        //     //         console.log('内容脚本检查超时，继续执行...');
        //     //         resolve();
        //     //     }, 2000);
                
        //     //     // 发送一个测试消息
        //     //     chrome.tabs.sendMessage(activeTab.id, { type: 'PING' }, response => {
        //     //         clearTimeout(timeout);
        //     //         if (chrome.runtime.lastError) {
        //     //             console.log('内容脚本可能未加载，尝试重新加载页面...');
        //     //             // 如果出错，可能是内容脚本未加载，我们尝试重新加载页面
        //     //             chrome.tabs.reload(activeTab.id, {}, () => {
        //     //                 // 给页面一些时间加载内容脚本
        //     //                 setTimeout(() => {
        //     //                     console.log('页面已重新加载，继续执行...');
        //     //                     resolve();
        //     //                 }, 2000); // 增加等待时间，确保内容脚本加载完成
        //     //             });
        //     //         } else {
        //     //             console.log('内容脚本已加载，继续执行...');
        //     //             resolve();
        //     //         }
        //     //     });
        //     // });
            
        //     // 使用CollectionManager代替GetUrl，直接发送开始收藏的消息
        //     const startCollectionAction = CollectionManager.createStartCollectionAction();
        //     console.log('发送收藏动作消息:', startCollectionAction);
            
        //     try {
        //         const result = await sendMessage(activeTab.id, startCollectionAction);
        //         console.log('收藏动作响应结果:', result);
        //         debugger;
        //         // 检查收藏结果
        //         if (result.message === 'error') {
        //             console.error('Collection failed:', result.error);
        //         } else {
        //             console.log('Collection successful:', result);
        //         }
        //     } catch (error) {
        //         console.error('发送收藏消息失败:', error);
        //         // 显示错误通知
        //         chrome.notifications.create({
        //             type: 'basic',
        //             iconUrl: 'icon-128.png',
        //             title: '收藏失败',
        //             message: '无法与内容脚本建立连接，请刷新页面后重试。',
        //             priority: 2
        //         });
        //     }
        // } catch (error) {
        //     console.error('执行内容脚本检查时出错:', error);
        }
        //
    // }
    );
}

// 创建右键菜单按钮
chrome.contextMenus.create({
    id: "knowledge-harvest-context-menu",
    title: "Save to InfoKeyMind",
    contexts: ["all"], // 可以是 "page", "frame", "selection", "link", "image", "video", "audio" 等
});

/**
 * 监听右键菜单点击事件
 */
chrome.contextMenus.onClicked.addListener(function(info) {
    if (info.menuItemId === 'knowledge-harvest-context-menu') {
        onCollectCurrentPage()
    }
});

/**
 * 监听浏览器按钮点击事件
 */
chrome.action.onClicked.addListener(function(tab) {
    onCollectCurrentPage()
});
